voicemeeter\interface\parameters/
recorder.rs

1//! Recorder
2use super::*;
3use errors::*;
4
5/// Recorder parameters
6pub struct VoicemeeterRecorder<'a> {
7    remote: &'a VoicemeeterRemote,
8}
9
10impl<'a> VoicemeeterRecorder<'a> {
11    #[doc(hidden)]
12    pub fn new(remote: &'a VoicemeeterRemote) -> Self {
13        VoicemeeterRecorder { remote }
14    }
15
16    /// Get the identifier for an option: `Recorder.{dot}`
17    pub fn param(&self, dot: impl Display) -> Cow<'static, ParameterNameRef> {
18        Cow::Owned(format!("{RECORDER}.{dot}").into())
19    }
20    /// Stop the recorder
21    pub fn stop(&self) -> BoolParameter<'_> {
22        BoolParameter::new(self.param("stop"), self.remote)
23    }
24    /// Start the recorder
25    pub fn play(&self) -> BoolParameter<'_> {
26        BoolParameter::new(self.param("play"), self.remote)
27    }
28    /// Play from position
29    pub fn replay(&self) -> BoolParameter<'_> {
30        BoolParameter::new(self.param("replay"), self.remote)
31    }
32    /// Fast forward
33    pub fn ff(&self) -> BoolParameter<'_> {
34        BoolParameter::new(self.param("ff"), self.remote)
35    }
36    /// Rewind
37    pub fn rew(&self) -> BoolParameter<'_> {
38        BoolParameter::new(self.param("rew"), self.remote)
39    }
40    /// Goto position
41    pub fn goto(&self) -> StringParameter<'_> {
42        StringParameter::new(self.param("goto"), self.remote)
43    }
44
45    /// Set the assignation of the recorder
46    pub fn out_bus_assignation(&self, bus: &Device) -> Result<BoolParameter<'_>, ParameterError> {
47        if !bus.is_bus() {
48            return Err(InvalidTypeError::ExpectedBus {
49                device: format!("{bus:?}"),
50            }
51            .into());
52        }
53        Ok(BoolParameter::new(
54            self.param(
55                bus.as_bus_index(&self.remote.program)
56                    .ok_or(DeviceError {
57                        program: self.remote.program,
58                        device: *bus,
59                    })?
60                    .1,
61            ),
62            self.remote,
63        ))
64    }
65
66    /// Record
67    pub fn record(&self) -> BoolParameter<'_> {
68        BoolParameter::new(self.param("record"), self.remote)
69    }
70
71    /// Pause
72    pub fn pause(&self) -> BoolParameter<'_> {
73        BoolParameter::new(self.param("pause"), self.remote)
74    }
75
76    /// Load a file to play in the recorder
77    pub fn load(&self) -> StringParameter<'a, true, false> {
78        StringParameter::new(self.param("load"), self.remote)
79    }
80
81    /// Set samplerate
82    pub fn samplerate(&self) -> IntParameter<'_> {
83        IntParameter::new(self.param("samplerate"), self.remote, 0..=2)
84    }
85
86    /// Arm a strip to use as pre-fader input (multiple)
87    pub fn arm_strip(&self, strip: impl StripIndex) -> Result<BoolParameter<'_>, ParameterError> {
88        Ok(BoolParameter::new(
89            self.param(format_args!(
90                "ArmStrip({})",
91                strip.into_strip_index(&self.remote.program)?
92            )),
93            self.remote,
94        ))
95    }
96
97    /// Arm a bus to use as post-fader output (single)
98    pub fn arm_bus(&self, bus: impl BusIndex) -> Result<BoolParameter<'_>, ParameterError> {
99        Ok(BoolParameter::new(
100            self.param(format_args!(
101                "ArmBus({})",
102                bus.into_bus_index(&self.remote.program)?
103            )),
104            self.remote,
105        ))
106    }
107
108    /// Mode options
109    pub fn mode(&self) -> VoicemeeterRecorderMode<'a> {
110        VoicemeeterRecorderMode::new(self.remote)
111    }
112
113    /// Set the bit resolution. On of `8`, `16`, `24`, `32`
114    pub fn bit_resolution(&self) -> IntParameter<'_> {
115        IntParameter::new(self.param("bitResolution"), self.remote, 8..=32)
116    }
117
118    /// Channels to use for recording post-fader outputs, `2`, `4`, `6`, `8`
119    pub fn channel(&self) -> IntParameter<'_> {
120        IntParameter::new(self.param("Channel"), self.remote, 1..=8)
121    }
122
123    /// Set the bitrate for the recording of mp3
124    pub fn kbps(&self) -> IntParameter<'_> {
125        IntParameter::new(self.param("kbps"), self.remote, 32..=320)
126    }
127
128    /// Set the file type for the recording
129    ///
130    /// | i | Type |
131    /// |---|------|
132    /// |1  | WAV| ,
133    /// |2  | AIFF|
134    /// |3 | BWF|
135    /// |100 | MP3|
136    pub fn file_type(&self) -> IntParameter<'_> {
137        IntParameter::new(self.param("FileType"), self.remote, 1..=100)
138    }
139
140    /// Set playback gain
141    pub fn gain(&self) -> FloatParameter<'_> {
142        FloatParameter::new(self.param("gain"), self.remote, -60.0..=12.0)
143    }
144}
145
146/// Mode options for recorder
147pub struct VoicemeeterRecorderMode<'a> {
148    remote: &'a VoicemeeterRemote,
149}
150
151impl<'a> VoicemeeterRecorderMode<'a> {
152    fn new(remote: &'a VoicemeeterRemote) -> Self {
153        VoicemeeterRecorderMode { remote }
154    }
155
156    /// Get the identifier for an option: `Recorder.mode.{dot}`
157    pub fn param(&self, dot: impl Display) -> Cow<'static, ParameterNameRef> {
158        Cow::Owned(format!("{RECORDER}.mode.{dot}").into())
159    }
160
161    /// Record bus
162    pub fn recbus(&self) -> BoolParameter<'_> {
163        BoolParameter::new(self.param("recbus"), self.remote)
164    }
165
166    /// Play on load
167    pub fn play_on_load(&self) -> BoolParameter<'_> {
168        BoolParameter::new(self.param("PlayOnLoad"), self.remote)
169    }
170
171    /// Loop
172    pub fn loop_(&self) -> BoolParameter<'_> {
173        BoolParameter::new(self.param("Loop"), self.remote)
174    }
175
176    /// MultiTrack
177    pub fn multi_track(&self) -> BoolParameter<'_> {
178        BoolParameter::new(self.param("MultiTrack"), self.remote)
179    }
180}